7F0C91D0	genrate a sample table
	accepts: A0: target, A1:total sample table size?, A2=table#3 entry (table entries?)
	
	SP+0x60	count of smallest Sbuf 1st sample (prev2)
	SP+0x64	count of smallest Sbuf 2nd sample (prev1)
	SP+0x70	
	SP+0x78	0x2000 buffer of short values
	SP+0x2078	0x1000 buffer of short values
	SP+0x3078	target address / table#3 entry (#entries?)
	SP+0x307C	total size of samples?
ADDIU	SP,SP,CF88	;SP-=0x3078
SW	RA,002C (SP)
SW	S4,0028 (SP)
SW	S1,001C (SP)
OR	S4,A2,R0	;S4=A2: table#3 entry	[10]
SW	S3,0024 (SP)
SW	S2,0020 (SP)
SW	S0,0018 (SP)
SW	A0,3078 (SP)	;SP+3078=target
SW	A1,307C (SP)	;SP+307C=table#1 entry * S6*S7 (total size of samp1 and samp2?)
OR	RA,R0,R0	;RA=0!?
BLEZ	A2,7F0C9228	;branch if A2 is stupid (zero), which it shouldn't be at start!
OR	S1,R0,R0	;S1=0	counter
ADDIU	S0,SP,2078	;S0=SP+2078: 0x1000 buffer on stack - 0x800 buffer for shorts
//7F0C9208:	flood up to 0x100 entries starting at SP+2078
SW	RA,005C (SP)	;0->SP+5C
JAL	7F0CBF2C	;grab next 8 bits from datatable
ADDIU	A0,R0,0008	;A0=8
ADDIU	S1,S1,0001	;S1++	counter++
LW	RA,005C (SP)	;recover return address
ADDIU	S0,S0,0002	;S0+=2	next short in Sbuffer
BNE	S1,S4,7F0C9208	;loop to fill table#3 number of entries
SH	V0,FFFE (S0)	;save return value to buffer
//7F0C9228:	blank (-1) Lbuffer at 0x78
ADDIU	V0,SP,0078	;V0=SP+78
ADDIU	A0,SP,2078	;A0=p->data just placed in buffer
ADDIU	V1,R0,FFFF	;V1=-1
//7F0C9234:	set default values in large buffer
ADDIU	V0,V0,0004	;next two entries
SLTU	AT,V0,A0	;loop for 0x2000 buffer
SH	V1,FFFC (V0)	;-1 ->Lbuffer entry 1
BNEZ	AT,7F0C9234
SH	V1,FFFE (V0)	;-1 ->Lbuffer entry 2
//7F0C9248:
ADDIU	T0,R0,270F	;T0=270F	'previous' Sbuffer value
ADDIU	A2,R0,270F	;A2=270F	'prev2'-two entries ago
BLEZ	S4,7F0C9378	;branch if no entries?
OR	S1,R0,R0	;S1=0
ANDI	V0,S4,0001	;V0=test for final bit in sample size?
BEQ	V0,R0,7F0C92AC	;branch if not to final bit
ADDIU	T7,SP,2078	;T7=Sbuffer
LHU	V0,2078 (SP)
SLTI	AT,V0,270F
BEQL	AT,R0,7F0C9284
+SLTI	AT,V0,270F
ANDI	A2,V0,FFFF
BEQ	R0,R0,7F0C9294
SW	R0,0060 (SP)
SLTI	AT,V0,270F
//7F0C9284:
BEQL	AT,R0,7F0C9298
+LW	A3,0060 (SP)
LHU	A2,2078 (SP)
SW	R0,0060 (SP)
//7F0C9294:
LW	A3,0060 (SP)
LW	T1,0064 (SP)
ADDIU	S1,R0,0001
SW	A3,0060 (SP)
BEQ	S1,S4,7F0C936C
SW	T1,0064 (SP)
//7F0C92AC:
SLL	T6,S1,0x1	;T6=count->offset
ADDU	S0,T6,T7	;S0=offset + Sbuffer
LW	A3,0060 (SP)	;recall c@prev2 from previously saved values (init. 0)
LW	T1,0064 (SP)	;recall c@prev1 from previously saved values (init. 0)
//7F0C92BC:	Loopus Sbuffer!!
//entries go in pairs.  prev1 will be upper short, prev2 lower short
//determine the smallest prevs and the count they occur at
//
//determine smallest prev2
LHU	V1,0000 (S0)	;V1=value from Sbuffer
OR	A1,T0,R0	;A1=T0: 'previous' Sbuf val
OR	A0,A2,R0	;A0=A2: 'prev2' Sbuf val
SLT	AT,V1,T0	;TRUE if Sbuffer val < previous Sbuf val
BEQ	AT,R0,7F0C9300	;branch if cur > previous
OR	V0,V1,R0	;V0=V1: Sbuffer val
SLT	AT,A0,A1	;TRUE if prev2 < prev1
BEQL	AT,R0,7F0C92F4	;at first will always throw false!
+ANDI	A2,V1,FFFF	;A2=(unsigned short) Sbuffer value
ANDI	T0,V1,FFFF
OR	A1,T0,R0
BEQ	R0,R0,7F0C9318
OR	T1,S1,R0
-	ANDI	A2,V1,FFFF
//7F0C92F4:
OR	A0,A2,R0	;A0=A2: 'prev2' = Sbufval
BEQ	R0,R0,7F0C9318
OR	A3,S1,R0	;A3=S1: count for prev2
//7F0C9300:	current Sbuf val < previous
SLT	AT,V0,A0	;TRUE if Sbuf val < 'prev2'
BEQL	AT,R0,7F0C931C	;if it isn't, don't set A2=Sbuf
+LHU	V1,0002 (S0)	;V1=next Sbuf val
ANDI	A2,V1,FFFF	;A2=(unsigned char) Sbuf
OR	A0,A2,R0	;A0=A2: 'prev2'
OR	A3,S1,R0	;A3=S1: count
//7F0C9318:
LHU	V1,0002 (S0)	;V1=next value in Sbuffer
//7F0C931C:	determine smallest prev1
SLT	AT,V1,A1	;TRUE if Sbufnext < 'prev1'
BEQ	AT,R0,7F0C934C	;branch if not so much
OR	V0,V1,R0	;V0=V1: Sbufnext
SLT	AT,A0,A1	;TRUE if Sbufval < 'prev2'
BEQL	AT,R0,7F0C9344	;branch if not so much
+ANDI	A2,V1,FFFF	;A2=(unsigned short) next Sbuf val
ANDI	T0,V1,FFFF	;T0=(unsigned short) next Sbuf val
BEQ	R0,R0,7F0C9360
ADDIU	T1,S1,0001	;T1=count+1	count for smallest Sbufnext
-	ANDI	A2,V1,FFFF
//7F0C9344:
BEQ	R0,R0,7F0C9360
ADDIU	A3,S1,0001
//7F0C934C:
SLT	AT,V0,A0
BEQL	AT,R0,7F0C9364
ADDIU	S1,S1,0002
ANDI	A2,V1,FFFF
ADDIU	A3,S1,0001
//7F0C9360:
ADDIU	S1,S1,0002	;S1+=2	count+=2
//7F0C9364:
BNE	S1,S4,7F0C92BC	;loop if more entries left in table
ADDIU	S0,S0,0004	;S0+=4	Sbuffer+=4
//7F0C936C:	do something with extracted smallest pair
OR	S1,R0,R0	;S1=0
SW	A3,0060 (SP)	;store count of 1st instance of smallest prev2	[6]
SW	T1,0064 (SP)	;store count of 1st instance of smallest prev1	[5]
LW	A3,0060 (SP)	;A3=count of prev2
LW	T1,0064 (SP)	;T1=count of prev1
ADDIU	S3,SP,0078	;S3=SP+78: Lbuffer
ADDIU	T5,R0,270F	;T5=270F	
ADDIU	T4,R0,270F	;T4=270F
ADDIU	T3,SP,2078	;T3=SP+2078: Sbuffer
SLL	T8,A3,0x1	;T8=c@prev2->offset (short)
//7F0C9394:	+table loop target
//
//use set of entries to fill in table
SLL	T9,T1,0x1	;T9=c@prev1->offset (short)
ADDU	V0,T3,T9	;V0=Sbuffer+shorty
ADDU	A1,T3,T8	;A1=Sbuffer+shorty
LHU	T6,0000 (A1)	;T6=entry prev2
LHU	T7,0000 (V0)	;T7=entry prev1
SLL	T8,T1,0x2	;T8=c@prev1->offset (long)
SLL	T9,A3,0x2	;T9=c@prev2->offset (long)
ADDU	T2,T6,T7	;T2=prev1 + prev2	[1+1=2]
ADDU	A0,S3,T9	;A0=Lbuffer+longy
ADDU	V1,S3,T8	;V1=Lbuffer+longy
ADDIU	T0,R0,270F	;T0=270F
BNEZ	T2,7F0C93CC	;if T2=0, T2 is set to 1
ADDIU	A2,R0,270F	;A2=270F
ADDIU	T2,R0,0001	;T2=1
//7F0C93CC:	deal with Lbuf c@prev1 and Lbuf c@prev1+1 - unset
//
//
LH	T6,0000 (V1)	;T6=Lbuf entry c@prev1	lower short
SH	T4,0000 (V0)	;store 270F to Sbuf c@prev1
SH	T4,0000 (A1)	;store 270F to Sbuf c@prev2
BGEZL	T6,7F0C942C	;branch if it doesn't equal -1
+LH	T8,0000 (A0)	;T8=Lbuf entry c@prev2
LH	T7,0002 (V1)	;T7=Lbuf c@prev1+1		upper short
ADDIU	T8,T1,2710	;T8=c@prev1+2710
BGEZL	T7,7F0C942C	;branch if entry c@prev1+1 doesn't equal -1
+LH	T8,0000 (A0)	;T8=entry c@prev2
SH	T8,0000 (V1)	;save 2710+c@prev1 to Lbuf c@prev1
//7F0C93F4:	deal with Lbuf c@prev2 & Lbuf A3+1 - unset
LH	T9,0000 (A0)	;T9=Lbuf c@prev2
OR	S2,T1,R0	;S2=T1: c@prev1
SH	T2,0000 (V0)	;(Sbuf c@prev2 + Sbuf c@prev1) -> Sbuf c@prev1
BGEZ	T9,7F0C9420	;branch if not -1
NOP	
//7F0C9408:	Lbuf c@prev2 is -1...
LH	T6,0002 (A0)	;T6=Lbuf c@prev2+1
ADDIU	T7,A3,2710	;T7=c@prev2+2710
BGEZ	T6,7F0C9420	;branch if Lbuf c@prev2+1 isn't -1
NOP	
BEQ	R0,R0,7F0C94F8
SH	T7,0002 (V1)	;save 2710+c@prev2 -> Lbuf c@prev1+1
//7F0C9420:	if either upper or lower entry in Lbuf[c@prev2] set,
//		  save c@prev2 to upper entry in Lbuf[Lbuf c@prev1]
BEQ	R0,R0,7F0C94F8
SH	A3,0002 (V1)	;save c@prev2 -> Lbuf c@prev1+1
-	LH	T8,0000 (A0)	;T8=Lbuf[c@prev2]low
//7F0C942C:	if either upper or lower entry in Lbuf[c@prev1] set,
//		  save 
LH	T6,0078 (SP)	;T6=first entry in Lbuf
BGEZ	T8,7F0C9480	;branch if not -1
NOP	
LH	T9,0002 (A0)	;T9=Lbuf[c@prev2]hi
BGEZ	T9,7F0C9480	;branch if not -1
NOP	
ADDIU	T6,A3,2710	;T6=c@prev2 + 2710
SH	T6,0000 (A0)	;save (c@prev2+2710) -> Lbuf[c@prev2]low
LH	T7,0000 (V1)	;T7=Lbuf[c@prev1] lower value
OR	S2,A3,R0	;S2=c@prev2
SH	T2,0000 (A1)	;(Sbuf c@prev2 + Sbuf c@prev1) -> Sbuf[c@prev2]
BGEZ	T7,7F0C9478	;branch if Lbuf[c@prev1]low != -1
NOP	
LH	T8,0002 (V1)	;T8=Lbuf[c@prev1] upper value
ADDIU	T9,T1,2710	;T9=c@prev1+2710
BGEZ	T8,7F0C9478	;branch if Lbuf[c@prev1]hi != -1
NOP	
BEQ	R0,R0,7F0C94F8
SH	T9,0002 (A0)	;save c@prev1+2710 -> Lbuf[c@prev2]hi
//7F0C9478:	if either Lbuf[c@prev1] values set, 
//		  store c@prev1 -> Lbuf[c@prev2]hi
BEQ	R0,R0,7F0C94F8
SH	T1,0002 (A0)	;save c@prev1 -> Lbuf[c@prev2]hi
//7F0C9480:	if either Lbuf[c@prev2] values set,
//		
//
BGEZ	T6,7F0C94A8	;branch if Lbuf[0] != -1
OR	S2,R0,R0	;S2=0
SLL	T7,R0,0x2	;T7=0
ADDU	V0,S3,T7	;V0=Lbuf+0
LH	T8,0002 (V0)	;T8=Lbuf[1]
LHU	T9,2078 (SP)	;T9=Sbuf[0]
BGEZ	T8,7F0C94A8
SLTI	AT,T9,270F
BEQL	AT,R0,7F0C94E8	;skip all this if Sbuf=9999 or above
SLL	T8,S2,0x1
//7F0C94A8:
ADDIU	S2,S2,0001
//7F0C94AC:
SLL	T6,S2,0x2
ADDU	V0,S3,T6
LH	T7,0000 (V0)
BGEZL	T7,7F0C94AC
ADDIU	S2,S2,0001
LH	T8,0002 (V0)
BGEZL	T8,7F0C94AC
ADDIU	S2,S2,0001
SLL	T9,S2,0x1
ADDU	T6,T3,T9
LHU	T7,0000 (T6)
SLTI	AT,T7,270F
BNEL	AT,R0,7F0C94AC
ADDIU	S2,S2,0001
SLL	T8,S2,0x1
//7F0C94E8:
ADDU	T9,T3,T8
SH	T2,0000 (T9)
SH	T1,0000 (V0)
SH	A3,0002 (V0)
//7F0C94F8:	stupid tests really, since neither branch condition can occur
BLEZ	S4,7F0C95FC	;kill if there are no more bits in sample register thingy
ANDI	V0,S4,0001	;V0=bit test
//7F0C9500:
BEQL	V0,R0,7F0C9544	;branch while bits remain
+SLL	T6,S1,0x1	;T6=count->offset	count*2
LHU	V0,2078 (SP)
ADDIU	S1,R0,0001
SLTI	AT,V0,270F
BEQL	AT,R0,7F0C952C
SLTI	AT,V0,270F
ANDI	A2,V0,FFFF
BEQ	R0,R0,7F0C953C
OR	A3,R0,R0
-	SLTI	AT,V0,270F
//7F0C952C:
BEQ	AT,R0,7F0C953C
NOP	
LHU	A2,2078 (SP)
OR	A3,R0,R0
//7F0C953C:
BEQ	S1,S4,7F0C95F8
SLL	T6,S1,0x1
//7F0C9544:
ADDU	S0,T3,T6	;S0=Sbuffer[count]
//7F0C9548:	determine new smallest values from remaining
//
//determine smallest prev2 value
LHU	V1,0000 (S0)	;V1=Sbuf[count]low val
OR	A1,T0,R0	;A1=T0: prev1
OR	A0,A2,R0	;A0=A2: prev2
SLT	AT,V1,T0	;TRUE if Sbufval < prev1
BEQ	AT,R0,7F0C958C	;branch if not smaller than test sample
OR	V0,V1,R0	;V0=Sbufval
SLT	AT,A0,A1	;TRUE if prev2 < prev1
BEQL	AT,R0,7F0C9580	;branch if values equal or prev1<prev2
+ANDI	A2,V1,FFFF	;A2=(unsigned short) Sbufval
ANDI	T0,V1,FFFF	;T0=(unsigned short) Sbufval
OR	A1,T0,R0	;A1=prev1=(unsigned short) Sbufval
BEQ	R0,R0,7F0C95A4
OR	T1,S1,R0	;T1=S1: save count as c@prev1
-	ANDI	A2,V1,FFFF
//7F0C9580:	set new prev2 values
OR	A0,A2,R0	;A0=A2: new prev2 value
BEQ	R0,R0,7F0C95A4
OR	A3,S1,R0	;A3=S1: save current count as c@prev2
//7F0C958C:
SLT	AT,V0,A0	;TRUE if Sbufval < prev2
BEQL	AT,R0,7F0C95A8	;do nothing if value is larger
+LHU	V1,0002 (S0)	;V1=Sbuf[count]hi val
ANDI	A2,V1,FFFF	;A2=(unsigned short)Sbufnext
OR	A0,A2,R0	;A0=A2: prev2=Sbufval
OR	A3,S1,R0	;A3=S1: save count as c@prev2
//7F0C95A4:
//
//determine smallest prev1 values
LHU	V1,0002 (S0)	;V1=next Sbufval
SLT	AT,V1,A1	;TRUE if Sbufnext < prev1
BEQ	AT,R0,7F0C95D8	;
OR	V0,V1,R0	;V0=V1: Sbufnext
SLT	AT,A0,A1	;TRUE if prev2 < prev1
BEQL	AT,R0,7F0C95D0
+ANDI	A2,V1,FFFF	;A2=(unsigned short) next Sbuf
ANDI	T0,V1,FFFF	;T0=(unsigned short) next Sbuf
BEQ	R0,R0,7F0C95EC
ADDIU	T1,S1,0001	;T1=count+1
-	ANDI	A2,V1,FFFF
//7F0C95D0:
BEQ	R0,R0,7F0C95EC
ADDIU	A3,S1,0001	;A3=count+1
//7F0C95D8:
SLT	AT,V0,A0		;TRUE if Sbufnext < prev2
BEQL	AT,R0,7F0C95F0
+ADDIU	S1,S1,0002	;count+=2
ANDI	A2,V1,FFFF	;A2=(unsigned short) Sbufnext
ADDIU	A3,S1,0001	;A3=count+1
//7F0C95EC:	loop until entries are scanned
ADDIU	S1,S1,0002	;count+=2
BNE	S1,S4,7F0C9548	;branch while there are more entries
ADDIU	S0,S0,0004	;p->next set of entries in Sbuffer
//7F0C95F8:
//
//RA=1 if prev1 or prev2 == loop value (270F)
OR	S1,R0,R0	;S1=0
BEQL	T5,T0,7F0C9610	;branch if 270F == prev1
+ADDIU	RA,R0,0001	;RA=1
BNE	T5,A2,7F0C9610	;branch if 270F != prev2 just determined
NOP	
ADDIU	RA,R0,0001	;RA=1
//7F0C9610:	loop until entire table is filled by entries, using pairs of smallest values
BEQL	RA,R0,7F0C9394	;determine next smallest pair until out of entries
+SLL	T8,A3,0x1
//7F0C9618:	set up for final sample table
LW	T7,307C (SP)	;total sample size thingy?
SW	S2,0070 (SP)	;save ? to SP+70	probably actual start of table
ADDIU	S3,SP,0078	;S3=Lbuffer
BLEZ	T7,7F0C969C	;quit if total size invalid
LW	V0,3078 (SP)	;V0=p->target	[803B06A0]
SLTI	AT,S2,2710	;TRUE if start < 2710 (in other words, if there are entries)
//7F0C9630:	build final sample table, saving to target
//
//
BEQ	AT,R0,7F0C9664	;branch if pos is a 2710 type
OR	S0,S2,R0	;S0=S2: pos
//7F0C9638:
JAL	7F0CBF2C	;returns V0=A0#bits from datatable
ADDIU	A0,R0,0001	;grab next bit from datatable
SLL	T8,S0,0x2	;T8=pos->offset	SO*4	entry in table
ADDU	T9,S3,T8	;T9=Lbuffer + longoffset
SLL	T6,V0,0x1	;T6=bit*2	upper or lower table entry
ADDU	T7,T9,T6	;T7=Lbuffer + longoffset + shortoffset
LH	S0,0000 (T7)	;S0=Lbufval (new pos)
SLTI	AT,S0,2710
BNEZ	AT,7F0C9638	;loop if Lbufval < 2710; use Lbufval as next index in Lbuf
NOP	
LW	V0,3078 (SP)	;V0=p->target
//7F0C9664:	handle 2710+ entries
SLTI	AT,S4,0101	;TRUE if #entries < 101
BEQ	AT,R0,7F0C9680	;branch if #entries exceeds 0x100, which it can't(?)
ADDIU	T6,S0,D8F0	;T6=Lbufval-0x2710
ADDIU	T8,S0,D8F0	;T8=Lbufval-0x2710
ADDU	T9,V0,S1	;T9=target+count
BEQ	R0,R0,7F0C968C
SB	T8,0000 (T9)	;Lbufval-2710 -> target+count
//7F0C9680:	if #entries > 100, target is a short, not a byte
SLL	T7,S1,0x1	;T7=count->shortoffset
ADDU	T8,V0,T7	;T8=target+count*2
SH	T6,0000 (T8)	;Lbufval-2710 -> target+count*2
//7F0C968C:	loop for total size of samples
LW	T9,307C (SP)	;T9=total size of samples
ADDIU	S1,S1,0001	;S1++	count++
BNEL	S1,T9,7F0C9630	;loop for all
+SLTI	AT,S2,2710	;TRUE if pos < 2710
//7F0C969C:	tidy up and return
LW	RA,002C (SP)
LW	S0,0018 (SP)
LW	S1,001C (SP)
LW	S2,0020 (SP)
LW	S3,0024 (SP)
LW	S4,0028 (SP)
JR	RA
ADDIU	SP,SP,3078

